#include <iostream>
#include <string>
#include <cstring>

// 添加缺失的 MatcherContext 结构体定义
struct MatcherContext {
    size_t pIdx = 0;           // pattern索引
    size_t vIdx = 0;           // value索引
    size_t lastStar = std::string::npos;  // 最后一个星号位置
    size_t lastMatch = 0;      // 最后匹配位置
    bool sawSep = false;       // 是否遇到分隔符
};

// 添加缺失的 GetCharAt 函数定义
static char GetCharAt(const std::string& str, size_t index)
{
    return (index < str.size()) ? str[index] : '\0';
}

// 修改后的函数签名
static bool SkipConsecutiveWildcards(const std::string& pattern, MatcherContext& ctx)
{
    size_t patternSize = pattern.size();
    while (ctx.pIdx < patternSize && pattern[ctx.pIdx] == '*') {
        ctx.pIdx++;
    }
    return ctx.pIdx >= patternSize; // 返回是否已到pattern末尾
}

static void HandleWildcardMatch(const std::string& pattern, MatcherContext& ctx)
{
    ctx.lastStar = ctx.pIdx - 1;
    ctx.lastMatch = ctx.vIdx;
    
    // 检查下一个字符是否是分隔符
    if (ctx.pIdx < pattern.size() && pattern[ctx.pIdx] == '=') {
        ctx.sawSep = true;
    }
}

static bool PerformBacktrack(MatcherContext& ctx, const std::string& pattern, const std::string& value)
{
    if (ctx.lastStar == std::string::npos) {
        return false; // 无法回溯
    }
    
    ctx.pIdx = ctx.lastStar + 1;
    ctx.lastMatch++;
    ctx.vIdx = ctx.lastMatch;
    
    // 如果之前遇到过分隔符，则需要特殊处理
    if (ctx.vIdx < value.size() && ctx.sawSep) {
        char nextPatternChar = GetCharAt(pattern, ctx.pIdx);
        if (nextPatternChar != '\0') {
            while (ctx.vIdx < value.size() && value[ctx.vIdx] != nextPatternChar) {
                ctx.vIdx++;
            }
        }
    }
    
    return true;
}

static bool SkipToEndOfWildcards(const std::string& pattern, MatcherContext& ctx)
{
    while (ctx.pIdx < pattern.size() && pattern[ctx.pIdx] == '*') {
        ctx.pIdx++;
    }
    return ctx.pIdx >= pattern.size(); // pattern是否完全由'*'组成
}

static bool MatchWithWildcard(const std::string& pattern, const std::string& value)
{
    MatcherContext ctx;  // 使用结构体管理所有状态
    
    size_t patternSize = pattern.size();
    size_t valueSize = value.size();
    
    while (ctx.pIdx < patternSize && ctx.vIdx <= valueSize) {
        char pChar = GetCharAt(pattern, ctx.pIdx);
        char vChar = GetCharAt(value, ctx.vIdx);
        
        if (pChar == '*') {
            // 处理连续的'*'
            if (SkipConsecutiveWildcards(pattern, ctx)) {
                return true; // '*'在末尾，匹配任意内容
            }
            
            HandleWildcardMatch(pattern, ctx);
            continue;
        }
        
        if (pChar == vChar) {
            // 记录是否遇到分隔符
            if (pChar == '=') {
                ctx.sawSep = true;
            }
            ctx.pIdx++;
            ctx.vIdx++;
        } else {
            // 字符不匹配，尝试回溯
            if (!PerformBacktrack(ctx, pattern, value)) {
                return false;
            }
        }
    }
    
    // 跳过末尾的'*'
    SkipToEndOfWildcards(pattern, ctx);
    
    return (ctx.pIdx >= patternSize && ctx.vIdx >= valueSize);
}

int main()
{
    std::string pattern = "***=()*";
    std::string value = "LC_=()12345";
    
    bool result = MatchWithWildcard(pattern, value);
    std::cout << (result ? "success" : "fail") << std::endl;
    
    return 0;
}